package com.ruoyi.web.controller.post.service.impl;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.HashSet;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.ruoyi.web.controller.post.domain.Post;
import com.ruoyi.web.controller.post.domain.PostRecommendationHistory;
import com.ruoyi.web.controller.post.mapper.PostContentMapper;
import com.ruoyi.web.controller.post.mapper.PostRecommendationHistoryMapper;
import com.ruoyi.web.controller.post.service.IPostRecommendationService;
import com.ruoyi.web.controller.post.service.IPostService;

/**
 * 帖子推荐 服务层实现（重构版 - 修复三级排序逻辑）
 *
 * @author thunderhub
 */
@Service
public class PostRecommendationServiceImpl implements IPostRecommendationService
{
    private static final Logger logger = LoggerFactory.getLogger(PostRecommendationServiceImpl.class);

    @Autowired
    private PostRecommendationHistoryMapper postRecommendationHistoryMapper;

    @Autowired
    private PostContentMapper postContentMapper;

    @Autowired
    private IPostService postService;

    /**
     * 获取推荐帖子列表（按点赞数排序，使用三级排序逻辑）
     *
     * @param userId 用户ID，如果为null则表示未登录用户
     * @param limit 推荐数量限制
     * @return 推荐帖子列表
     */
    @Override
    public List<Post> getRecommendedPostsByLikes(Long userId, int limit)
    {
        try {
            logger.info("开始获取基础推荐帖子列表，用户ID: {}, 限制数量: {}", userId, limit);

            // 获取用户访问过的帖子ID列表
            final Set<Long> visitedPostIds = userId != null ? new HashSet<>(getVisitedPostIds(userId)) : new HashSet<>();
            logger.info("用户已访问帖子数量: {}", visitedPostIds.size());

            // 查询所有正常状态的帖子
            Post query = new Post();
            query.setStatus("1"); // 只查询已发布的帖子
            List<Post> allPosts = postService.selectPostList(query);
            logger.info("查询到的所有正常帖子数量: {}", allPosts.size());

            // 三级排序：推广帖子 > 未访问帖子 > 已访问帖子，每级内按点赞数排序
            List<Post> sortedPosts = allPosts.stream()
                    .sorted((post1, post2) -> {
                        // 第一级：推广状态比较（推广帖子优先）
                        boolean isPromoted1 = post1.getPromotionPlanId() != null && post1.getPromotionPlanId() > 0;
                        boolean isPromoted2 = post2.getPromotionPlanId() != null && post2.getPromotionPlanId() > 0;

                        if (isPromoted1 && !isPromoted2) return -1;
                        if (!isPromoted1 && isPromoted2) return 1;

                        // 第二级：访问状态比较（未访问优先）
                        boolean isVisited1 = visitedPostIds.contains(post1.getPostId());
                        boolean isVisited2 = visitedPostIds.contains(post2.getPostId());

                        if (!isVisited1 && isVisited2) return -1;
                        if (isVisited1 && !isVisited2) return 1;

                        // 第三级：在同等级内按点赞数降序排列
                        Long likes1 = post1.getLikes() != null ? post1.getLikes() : 0L;
                        Long likes2 = post2.getLikes() != null ? post2.getLikes() : 0L;
                        return likes2.compareTo(likes1);
                    })
                    .limit(limit > 0 ? limit : Integer.MAX_VALUE) // 如果limit为0或负数，则不限制
                    .collect(Collectors.toList());

            logger.info("三级排序完成，为用户ID: {} 推荐了 {} 篇帖子", userId, sortedPosts.size());

            // 统计各类型帖子数量（用于调试）
            long promotedCount = sortedPosts.stream().filter(p -> p.getPromotionPlanId() != null && p.getPromotionPlanId() > 0).count();
            long unvisitedCount = sortedPosts.stream().filter(p -> !visitedPostIds.contains(p.getPostId())).count();
            long visitedCount = sortedPosts.stream().filter(p -> visitedPostIds.contains(p.getPostId())).count();
            logger.info("帖子类型统计 - 推广: {}, 未访问: {}, 已访问: {}", promotedCount, unvisitedCount, visitedCount);

            return sortedPosts;

        } catch (Exception e) {
            logger.error("获取推荐帖子时发生错误", e);
            return new ArrayList<>();
        }
    }

    /**
     * 获取推荐帖子列表（支持分类和关键词筛选，使用三级排序）
     * 修复版：正确的优先级 - 未访问帖子优先，已访问帖子排在最后
     */
    @Override
    public List<Post> getRecommendedPostsByLikesWithFilter(Long userId, int limit, String category, String keyword)
    {
        try {
            logger.info("开始获取筛选推荐帖子，用户ID: {}, 分类: {}, 关键词: {}", userId, category, keyword);

            // 获取用户访问过的帖子ID列表
            final Set<Long> visitedPostIds = userId != null ? new HashSet<>(getVisitedPostIds(userId)) : new HashSet<>();

            // 构建查询条件
            Post query = new Post();
            query.setStatus("1"); // 只查询已发布的帖子

            if (category != null && !category.trim().isEmpty() && !"all".equals(category)) {
                query.setTags(category);
                logger.info("应用分类筛选: {}", category);
            }

            List<Post> allPosts = postService.selectPostList(query);
            logger.info("基础查询到的帖子数量: {}", allPosts.size());

            // 关键词筛选
            if (keyword != null && !keyword.trim().isEmpty()) {
                String searchKeyword = keyword.toLowerCase();
                allPosts = allPosts.stream()
                        .filter(post -> {
                            return (post.getTitle() != null && post.getTitle().toLowerCase().contains(searchKeyword)) ||
                                    (post.getSummary() != null && post.getSummary().toLowerCase().contains(searchKeyword)) ||
                                    (post.getTags() != null && post.getTags().toLowerCase().contains(searchKeyword));
                        })
                        .collect(Collectors.toList());
                logger.info("关键词筛选后的帖子数量: {}", allPosts.size());
            }

            // 排序：未访问帖子优先，已访问帖子排在最后
            // 1. 未访问的推广帖子
            // 2. 未访问的普通帖子
            // 3. 已访问的推广帖子
            // 4. 已访问的普通帖子
            List<Post> sortedPosts = allPosts.stream()
                    .sorted((post1, post2) -> {
                        boolean isVisited1 = visitedPostIds.contains(post1.getPostId());
                        boolean isVisited2 = visitedPostIds.contains(post2.getPostId());
                        boolean isPromoted1 = post1.getPromotionPlanId() != null && post1.getPromotionPlanId() > 0;
                        boolean isPromoted2 = post2.getPromotionPlanId() != null && post2.getPromotionPlanId() > 0;

                        // 第一级：访问状态比较（未访问帖子绝对优先，已访问帖子排最后）
                        if (!isVisited1 && isVisited2) return -1; // post1未访问，post2已访问 -> post1优先
                        if (isVisited1 && !isVisited2) return 1;  // post1已访问，post2未访问 -> post2优先

                        // 第二级：在相同访问状态内，推广帖子优先
                        if (isPromoted1 && !isPromoted2) return -1;
                        if (!isPromoted1 && isPromoted2) return 1;

                        // 第三级：在同等级内按点赞数降序排列
                        Long likes1 = post1.getLikes() != null ? post1.getLikes() : 0L;
                        Long likes2 = post2.getLikes() != null ? post2.getLikes() : 0L;
                        return likes2.compareTo(likes1);
                    })
                    .limit(limit > 0 ? limit : Integer.MAX_VALUE)
                    .collect(Collectors.toList());

            logger.info("筛选推荐完成，为用户ID: {} 推荐了 {} 篇帖子（分类: {}, 关键词: {}）",
                    userId, sortedPosts.size(), category, keyword);



            return sortedPosts;

        } catch (Exception e) {
            logger.error("获取筛选推荐帖子时发生错误", e);
            return new ArrayList<>();
        }
    }
    /**
     * 获取智能推荐帖子（支持分类和关键词筛选，使用三级排序+智能得分）
     * 修复版：完全过滤已访问帖子，绝对不返回已访问的内容
     */
    @Override
    public List<Post> getSmartRecommendedPostsWithFilter(Long userId, int limit, String userTags, String category, String keyword)
    {
        try {
            logger.info("开始获取智能推荐帖子，用户ID: {}, 用户标签: {}, 分类: {}, 关键词: {}",
                    userId, userTags, category, keyword);

            // 获取用户访问过的帖子ID列表
            final Set<Long> visitedPostIds = userId != null ? new HashSet<>(getVisitedPostIds(userId)) : new HashSet<>();
            logger.info("用户 {} 已访问帖子数量: {}", userId, visitedPostIds.size());

            // 构建查询条件
            Post query = new Post();
            query.setStatus("1"); // 只查询已发布的帖子

            if (category != null && !category.trim().isEmpty() && !"all".equals(category)) {
                query.setTags(category);
            }

            List<Post> allPosts = postService.selectPostList(query);
            logger.info("符合基础条件的帖子数量: {}", allPosts.size());

            // 第一步：完全过滤掉已访问的帖子
            List<Post> unvisitedPosts = allPosts.stream()
                    .filter(post -> !visitedPostIds.contains(post.getPostId()))
                    .collect(Collectors.toList());

            logger.info("过滤已访问帖子后剩余: {}", unvisitedPosts.size());

            // 第二步：关键词筛选
            if (keyword != null && !keyword.trim().isEmpty()) {
                String searchKeyword = keyword.toLowerCase();
                unvisitedPosts = unvisitedPosts.stream()
                        .filter(post -> {
                            return (post.getTitle() != null && post.getTitle().toLowerCase().contains(searchKeyword)) ||
                                    (post.getSummary() != null && post.getSummary().toLowerCase().contains(searchKeyword)) ||
                                    (post.getTags() != null && post.getTags().toLowerCase().contains(searchKeyword));
                        })
                        .collect(Collectors.toList());
                logger.info("关键词筛选后剩余帖子数量: {}", unvisitedPosts.size());
            }

            // 第三步：智能排序（只对未访问的帖子进行排序）
            // 1. 推广帖子优先
            // 2. 在同等推广状态下按智能得分降序排列
            List<Post> sortedPosts = unvisitedPosts.stream()
                    .sorted((post1, post2) -> {


                        // 第二级：在同等推广状态下按智能得分降序排列
                        double score1 = calculatePostScore(post1, userTags);
                        double score2 = calculatePostScore(post2, userTags);
                        return Double.compare(score2, score1);
                    })
                    .limit(limit > 0 ? limit : Integer.MAX_VALUE)
                    .collect(Collectors.toList());

            logger.info("智能推荐完成，为用户ID: {} 推荐了 {} 篇未访问帖子", userId, sortedPosts.size());

            // 验证：确保返回的帖子都是未访问的
            boolean hasVisitedPost = sortedPosts.stream()
                    .anyMatch(post -> visitedPostIds.contains(post.getPostId()));

            if (hasVisitedPost) {
                logger.error("警告：返回的推荐列表中包含已访问的帖子！");
            } else {
                logger.info("验证通过：所有返回的帖子都是未访问的");
            }

            return sortedPosts;

        } catch (Exception e) {
            logger.error("获取智能推荐帖子时发生错误", e);
            // 降级到基础推荐（也需要过滤已访问帖子）
            return getRecommendedPostsByLikesWithFilter(userId, limit, category, keyword);
        }
    }
    /**
     * 根据用户偏好获取推荐帖子（支持分类和关键词筛选，使用三级排序）
     * 兼容版：保持原有逻辑，确保方法调用链正确
     */
    @Override
    public List<Post> getPersonalizedRecommendedPostsWithFilter(Long userId, int limit, String category, String keyword)
    {
        if (userId == null) {
            return getRecommendedPostsByLikesWithFilter(null, limit, category, keyword);
        }

        try {
            // 分析用户历史访问的帖子，提取用户感兴趣的标签
            String userInterestTags = analyzeUserInterestTags(userId);
            logger.info("用户ID: {} 的兴趣标签: {}", userId, userInterestTags);

            // 使用智能推荐算法
            return getSmartRecommendedPostsWithFilter(userId, limit, userInterestTags, category, keyword);

        } catch (Exception e) {
            logger.error("获取个性化推荐帖子时发生错误，userId: {}", userId, e);
            // 降级到基础推荐
            return getRecommendedPostsByLikesWithFilter(userId, limit, category, keyword);
        }
    }

    /**
     * 记录用户访问帖子历史（增强异常处理）
     *
     * @param userId 用户ID
     * @param postId 帖子ID
     * @param visitType 访问类型（0=查看详情 1=推荐点击）
     * @return 结果
     */
    @Override
    public int recordUserVisit(Long userId, Long postId, String visitType)
    {
        try {
            if (userId == null || postId == null) {
                return 0;
            }

            // 检查是否已经存在访问记录
            PostRecommendationHistory existingRecord = null;
            try {
                existingRecord = postRecommendationHistoryMapper.selectByUserIdAndPostId(userId, postId);
            } catch (Exception e) {
                logger.warn("查询访问记录失败，可能是推荐历史表不存在，userId: {}, postId: {}", userId, postId);
                return 0;
            }

            if (existingRecord != null) {
                // 如果已存在记录，更新访问时间
                existingRecord.setVisitTime(getCurrentTimeString());
                existingRecord.setVisitType(visitType);
                return postRecommendationHistoryMapper.updatePostRecommendationHistory(existingRecord);
            } else {
                // 创建新的访问记录
                PostRecommendationHistory history = new PostRecommendationHistory();
                history.setUserId(userId);
                history.setPostId(postId);
                history.setVisitTime(getCurrentTimeString());
                history.setVisitType(visitType != null ? visitType : "0");

                // 获取帖子标题（可选）
                try {
                    Post post = postService.selectPostById(postId);
                    if (post != null) {
                        history.setPostTitle(post.getTitle());
                    }
                } catch (Exception e) {
                    logger.warn("获取帖子标题失败，postId: {}", postId);
                }

                return postRecommendationHistoryMapper.insertPostRecommendationHistory(history);
            }

        } catch (Exception e) {
            logger.warn("记录用户访问历史失败，可能是推荐历史表不存在，userId: {}, postId: {}, error: {}",
                    userId, postId, e.getMessage());
            return 0;
        }
    }

    /**
     * 检查用户是否访问过某个帖子
     *
     * @param userId 用户ID
     * @param postId 帖子ID
     * @return 是否访问过
     */
    @Override
    public boolean hasUserVisited(Long userId, Long postId)
    {
        if (userId == null || postId == null) {
            return false;
        }

        try {
            PostRecommendationHistory history = postRecommendationHistoryMapper.selectByUserIdAndPostId(userId, postId);
            return history != null;
        } catch (Exception e) {
            logger.warn("检查用户访问历史时发生错误，userId: {}, postId: {}, error: {}", userId, postId, e.getMessage());
            return false;
        }
    }

    /**
     * 获取用户访问过的帖子ID列表（增强异常处理）
     *
     * @param userId 用户ID
     * @return 帖子ID列表
     */
    @Override
    public List<Long> getVisitedPostIds(Long userId)
    {
        if (userId == null) {
            return new ArrayList<>();
        }

        try {
            List<Long> visitedIds = postRecommendationHistoryMapper.selectVisitedPostIdsByUserId(userId);
            logger.debug("用户ID: {} 访问过的帖子数量: {}", userId, visitedIds.size());
            return visitedIds;
        } catch (Exception e) {
            // 如果推荐历史表不存在或查询失败，记录警告并返回空列表
            logger.warn("无法获取用户访问历史，可能是推荐历史表不存在，userId: {}, error: {}", userId, e.getMessage());
            return new ArrayList<>();
        }
    }

    /**
     * 获取用户最近访问的帖子历史（增强异常处理）
     *
     * @param userId 用户ID
     * @param limit 查询数量限制
     * @return 访问历史列表
     */
    @Override
    public List<PostRecommendationHistory> getRecentVisitHistory(Long userId, int limit)
    {
        if (userId == null) {
            return new ArrayList<>();
        }

        try {
            return postRecommendationHistoryMapper.selectRecentVisitsByUserId(userId, limit);
        } catch (Exception e) {
            logger.warn("获取用户最近访问历史失败，可能是推荐历史表不存在，userId: {}, error: {}", userId, e.getMessage());
            return new ArrayList<>();
        }
    }

    /**
     * 清理用户过期的访问记录
     *
     * @param userId 用户ID
     * @param days 保留天数，超过此天数的记录将被删除。如果为0，则删除所有记录
     * @return 删除的记录数
     */
    @Override
    public int cleanExpiredVisitHistory(Long userId, int days)
    {
        if (userId == null) {
            return 0;
        }

        try {
            int deletedCount;
            if (days == 0) {
                // 如果天数为0，删除该用户的所有访问记录
                PostRecommendationHistory query = new PostRecommendationHistory();
                query.setUserId(userId);
                List<PostRecommendationHistory> allRecords = postRecommendationHistoryMapper.selectPostRecommendationHistoryList(query);

                if (!allRecords.isEmpty()) {
                    Long[] historyIds = allRecords.stream().map(PostRecommendationHistory::getHistoryId).toArray(Long[]::new);
                    deletedCount = postRecommendationHistoryMapper.deletePostRecommendationHistoryByIds(historyIds);
                } else {
                    deletedCount = 0;
                }
                logger.info("清理用户ID: {} 的所有访问记录，删除了 {} 条记录", userId, deletedCount);
            } else {
                // 删除超过指定天数的记录
                deletedCount = postRecommendationHistoryMapper.deleteExpiredRecordsByUserId(userId, days);
                logger.info("清理用户ID: {} 超过 {} 天的访问记录，删除了 {} 条记录", userId, days, deletedCount);
            }
            return deletedCount;
        } catch (Exception e) {
            logger.warn("清理用户过期访问记录时发生错误，userId: {}, days: {}, error: {}", userId, days, e.getMessage());
            return 0;
        }
    }

    /**
     * 获取智能推荐帖子（综合考虑点赞数、发布时间、标签相似度等因素，使用三级排序）
     *
     * @param userId 用户ID
     * @param limit 推荐数量限制
     * @param userTags 用户感兴趣的标签（可选）
     * @return 推荐帖子列表
     */
    @Override
    public List<Post> getSmartRecommendedPosts(Long userId, int limit, String userTags)
    {
        try {
            // 获取用户访问过的帖子ID列表
            final Set<Long> visitedPostIds = userId != null ? new HashSet<>(getVisitedPostIds(userId)) : new HashSet<>();

            // 查询所有正常状态的帖子
            Post query = new Post();
            query.setStatus("1"); // 只查询已发布的帖子
            List<Post> allPosts = postService.selectPostList(query);

            // 三级排序加智能得分
            List<Post> sortedPosts = allPosts.stream()
                    .sorted((post1, post2) -> {


                        // 第二级：访问状态比较（未访问优先）
                        boolean isVisited1 = visitedPostIds.contains(post1.getPostId());
                        boolean isVisited2 = visitedPostIds.contains(post2.getPostId());

                        if (!isVisited1 && isVisited2) return -1;
                        if (isVisited1 && !isVisited2) return 1;

                        // 第三级：在同等级内按智能得分降序排列
                        double score1 = calculatePostScore(post1, userTags);
                        double score2 = calculatePostScore(post2, userTags);
                        return Double.compare(score2, score1);
                    })
                    .limit(limit > 0 ? limit : Integer.MAX_VALUE)
                    .collect(Collectors.toList());

            logger.info("为用户ID: {} 智能推荐了 {} 篇帖子", userId, sortedPosts.size());
            return sortedPosts;

        } catch (Exception e) {
            logger.error("获取智能推荐帖子时发生错误", e);
            // 降级到基础推荐
            return getRecommendedPostsByLikes(userId, limit);
        }
    }

    /**
     * 根据用户偏好获取推荐帖子（基于用户历史访问的标签，使用三级排序）
     *
     * @param userId 用户ID
     * @param limit 推荐数量限制
     * @return 推荐帖子列表
     */
    @Override
    public List<Post> getPersonalizedRecommendedPosts(Long userId, int limit)
    {
        if (userId == null) {
            return getRecommendedPostsByLikes(null, limit);
        }

        try {
            // 分析用户历史访问的帖子，提取用户感兴趣的标签
            String userInterestTags = analyzeUserInterestTags(userId);

            // 使用智能推荐算法
            return getSmartRecommendedPosts(userId, limit, userInterestTags);

        } catch (Exception e) {
            logger.error("获取个性化推荐帖子时发生错误，userId: {}", userId, e);
            // 降级到基础推荐
            return getRecommendedPostsByLikes(userId, limit);
        }
    }

    /**
     * 计算帖子的综合得分
     *
     * @param post 帖子
     * @param userTags 用户感兴趣的标签
     * @return 综合得分
     */
    private double calculatePostScore(Post post, String userTags)
    {
        double score = 0.0;

        // 点赞数权重 (40%)
        Long likes = post.getLikes() != null ? post.getLikes() : 0L;
        score += likes * 0.1;

        // 浏览量权重 (20%)
        Long views = post.getViews() != null ? post.getViews() : 0L;
        score += (views / 10.0) * 0.2; // 除以10降低浏览量的影响

        // 评论数权重 (20%)
        Long comments = post.getComments() != null ? post.getComments() : 0L;
        score += comments * 0.1;

        // 收藏数权重 (10%)
        Long favorites = post.getFavorites() != null ? post.getFavorites() : 0L;
        score += favorites * 0.1;

        // 标签匹配权重 (10%)
        if (userTags != null && !userTags.trim().isEmpty() && post.getTags() != null) {
            double tagMatchScore = calculateTagMatchScore(post.getTags(), userTags);
            score += tagMatchScore * 0.5;
        }

        // 时间衰减因子（越新的帖子得分越高）
        double timeDecayFactor = calculateTimeDecayFactor(post.getPublishTime());
        score *= timeDecayFactor;

        return score;
    }

    /**
     * 计算标签匹配得分
     *
     * @param postTags 帖子标签
     * @param userTags 用户感兴趣的标签
     * @return 匹配得分
     */
    private double calculateTagMatchScore(String postTags, String userTags)
    {
        if (postTags == null || userTags == null) {
            return 0.0;
        }

        Set<String> postTagSet = new HashSet<>();
        Set<String> userTagSet = new HashSet<>();

        // 解析标签
        for (String tag : postTags.split(",")) {
            postTagSet.add(tag.trim().toLowerCase());
        }
        for (String tag : userTags.split(",")) {
            userTagSet.add(tag.trim().toLowerCase());
        }

        // 计算交集
        Set<String> intersection = new HashSet<>(postTagSet);
        intersection.retainAll(userTagSet);

        // 计算匹配度
        if (userTagSet.isEmpty()) {
            return 0.0;
        }

        return (double) intersection.size() / userTagSet.size() * 100;
    }

    /**
     * 计算时间衰减因子
     *
     * @param publishTime 发布时间
     * @return 时间衰减因子 (0.5 - 1.0)
     */
    private double calculateTimeDecayFactor(String publishTime)
    {
        if (publishTime == null) {
            return 0.5;
        }

        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date publishDate = sdf.parse(publishTime);
            Date now = new Date();

            long daysDiff = (now.getTime() - publishDate.getTime()) / (1000 * 60 * 60 * 24);

            // 30天内的帖子保持较高权重
            if (daysDiff <= 30) {
                return 1.0;
            } else if (daysDiff <= 90) {
                return 0.8;
            } else if (daysDiff <= 180) {
                return 0.6;
            } else {
                return 0.5;
            }

        } catch (Exception e) {
            return 0.5;
        }
    }

    /**
     * 分析用户感兴趣的标签（增强异常处理）
     *
     * @param userId 用户ID
     * @return 用户感兴趣的标签字符串
     */
    private String analyzeUserInterestTags(Long userId)
    {
        try {
            // 获取用户最近访问的帖子
            List<PostRecommendationHistory> recentVisits = getRecentVisitHistory(userId, 20);

            Set<String> allTags = new HashSet<>();

            for (PostRecommendationHistory visit : recentVisits) {
                try {
                    Post post = postService.selectPostById(visit.getPostId());
                    if (post != null && post.getTags() != null) {
                        for (String tag : post.getTags().split(",")) {
                            allTags.add(tag.trim());
                        }
                    }
                } catch (Exception e) {
                    logger.warn("分析用户兴趣标签时获取帖子失败，postId: {}", visit.getPostId());
                }
            }

            return String.join(",", allTags);

        } catch (Exception e) {
            logger.error("分析用户感兴趣标签时发生错误，userId: {}", userId, e);
            return "";
        }
    }

    /**
     * 获取当前时间字符串
     *
     * @return 时间字符串
     */
    private String getCurrentTimeString()
    {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(new Date());
    }
}